#include "TFloat.h"
#include <math.h>

unsigned int TFloat :: defaultTSize = 0;


TFloat :: TFloat(double _f, unsigned int _t) : f(_f), t(_t)
{
	truncate();
}


TFloat :: TFloat(const TFloat& _f) : f(_f.f), t(_f.t)
{
	truncate();
}


TFloat :: TFloat(double a) : f(a), t(defaultTSize)
{
	truncate();
}


TFloat& TFloat :: operator=(double a)
{
	f = a;
	t = defaultTSize;
	truncate();

	return *this;
}

double TFloat:: value() const
{
	return f;
}


TFloat& TFloat :: truncate()
{
	typedef long long int uint64;
	
	uint64 mask =  ~( (uint64(1) << (52 - t)) - 1);
	uint64 result = *reinterpret_cast<uint64*>(&f) & mask;
	f = *reinterpret_cast<double*>( &result );
	
	return *this;
}


void TFloat :: printDebug(std::ostream& o)
{
	typedef long long int uint64;

	uint64 x = *reinterpret_cast<uint64*>(&f);
	
	o << f << std::endl;
	o << *(double*)&x << std::endl;

	for (int i = 0 ; i < 64 ; ++i)
	{
		o << ((x & ( uint64(1) << (63 - i) ) )?"1":"0") ;
		if (i == 11)
		    o << " | ";
	}

	o << std::endl;
}


TFloat TFloat :: operator+(const TFloat& a) const
{
	return TFloat((f + a.f), t);
}


TFloat TFloat :: operator-(const TFloat& a) const
{
	return TFloat((f - a.f), t);
}


TFloat TFloat :: operator*(const TFloat& a) const
{
	return TFloat((f * a.f), t);
}


TFloat TFloat :: operator/(const TFloat& a) const
{
	return TFloat((f / a.f), t);
}


TFloat& TFloat :: operator=(const TFloat& a)
{
	t = a.t;
	f = a.f;
	return *this;
}


TFloat& TFloat :: operator+=(const TFloat& a)
{
	f += a.f;
	truncate();
	return *this;
}


TFloat& TFloat :: operator-=(const TFloat& a)
{
	f -= a.f;
	truncate();
	return *this;
}


TFloat& TFloat :: operator*=(const TFloat& a)
{
	f *= a.f;
	truncate();
	return *this;
}


TFloat& TFloat :: operator/=(const TFloat& a)
{
	f /= a.f;
	truncate();
	return *this;
}


TFloat TFloat :: squareRoot() const
{
	return TFloat(sqrt(f), t);
}


bool TFloat :: operator>(const TFloat& a) const
{
	return f > a.f;
}

